// 主应用入口
const { createApp } = Vue;
const { ElMessage, ElMessageBox } = ElementPlus;

// 创建Vue应用实例
const app = createApp({
    data() {
        return {
            // 文件列表数据（初始化为空数组，完全依赖后端数据）
            fileList: [],

            // 分页相关
            selectAll: false,
            currentPage: 1,
            pageSize: 10,
            totalFiles: 0,
            currentTab: "notImported", // 当前标签页

            // 弹窗相关
            showModal: false,
            modalTitle: "详情",
            isEditMode: false,
            isBatchMode: false, // 是否为批量修改模式
            selectedFiles: [], //批量修改时选中的文件
            formData: {
                // 基础信息
                place: "",
                company: "",
                productPhase: "",
                dataTypeFirst: "",
                dataTypeSecond: "",
                dataSource: "",
                startTime: "",
                channelNo: "",
                deviceNo: "",
                subject: "",
                remark: "",

                // 发动机信息
                engineId: "",
                engineNo: "",
                enginePlace: "",

                // 控制器信息
                ecuId: "",
                ecuNo: "",
                ecuSysId: "",
                ecuSysNo: "",

                // 时间信息
                uploadTime: "",
            },
        };
    },

    computed: {
        totalPages() {
            return Math.ceil(this.totalFiles / this.pageSize);
        },
    },

    methods: {
        // 文件选择
        selectFiles() {
            const input = document.createElement("input");
            input.type = "file";
            input.multiple = true;
            input.webkitdirectory = true; // 允许选择文件夹
            input.onchange = async (e) => {
                const files = Array.from(e.target.files);

                if (files.length > 0) {
                    try {
                        await this.uploadFiles(files);
                    } catch (error) {
                        console.error("文件上传失败:", error);
                    }
                }
            };
            input.click();
        },

        // 全选/取消全选
        toggleSelectAll(newSelectAll) {
            // 更新selectAll状态
            this.selectAll = newSelectAll;

            // 获取当前标签页的过滤文件列表
            const filteredFiles = this.getFilteredFiles();
            filteredFiles.forEach((file) => {
                // Vue 3中直接赋值即可，响应式系统会自动处理
                file.selected = this.selectAll;
            });

            // 强制触发响应式更新
            this.$forceUpdate();
        },

        // 更新全选状态
        updateSelectAll() {
            // 获取当前标签页的过滤文件列表
            const filteredFiles = this.getFilteredFiles();
            this.selectAll =
                filteredFiles.length > 0 &&
                filteredFiles.every((file) => file.selected);
        },

        // 获取当前标签页的过滤文件列表（现在直接返回当前文件列表，因为后端已经过滤）
        getFilteredFiles() {
            return this.fileList;
        },

        // 清空所有选中状态
        clearSelections() {
            this.fileList.forEach((file) => {
                // Vue 3中直接赋值即可，响应式系统会自动处理
                file.selected = false;
            });
            this.selectAll = false;
        },

        // 批量修改
        batchModify() {
            const selectedFiles = this.getFilteredFiles().filter(
                (file) => file.selected
            );

            if (selectedFiles.length === 0) {
                ElMessage.warning("请先选择要修改的记录");
                return;
            }
            // ElMessage.info(`将对 ${selectedFiles.length} 条记录进行批量修改`);
            //显示批量修改弹窗
            this.modalTitle = `批量修改 (${selectedFiles.length}条记录)`;
            this.isEditMode = true; //批量修改模式为编辑模式
            this.isBatchMode = true; //标记为批量模式
            this.selectedFiles = selectedFiles; //保存选中的文件
            //填充默认数据
            this.formData = {
                //基础信息
                projectNo: "", // 项目编号需要手动选择
                place: "",
                company: "航发黎明", // 默认航发黎明
                productPhase: "2", // 默认批产
                dataTypeFirst: "2", // 默认地面台架
                dataTypeSecond: "", // 数据第二分类需要手动选择
                dataSource: "testbed", // 默认台架数采
                startTime: "", // 运行起始时间需要手动填写
                channelNo: "",
                deviceNo: "", // 台架编号需要手动填写
                subject: "",
                remark: "",

                //发动机信息
                engineId: "",
                engineNo: "", // 发动机编号需要手动填写
                enginePlace: "",
                //控制器信息
                ecuId: "",
                ecuNo: "",
                ecuSysId: "",
                ecuSysNo: "",
                //时间信息
                uploadTime: "",
            };
            this.$nextTick(() => {
                this.showModal = true;
            });
        },

        // 批量导入
        async batchImport() {
            const selectedFiles = this.getFilteredFiles().filter(
                (file) => file.selected
            );
            if (selectedFiles.length === 0) {
                ElMessage.warning("请先选择要导入的记录");
                return;
            }

            // 使用统一的导入逻辑
            await this.executeImport(selectedFiles, false);
        },

        // 单个文件导入
        async importFile(file) {
            // 使用统一的导入逻辑
            await this.executeImport([file], true);
        },

        // 统一的导入执行逻辑
        async executeImport(files, isSingleImport) {
            try {
                // 0. 确保使用最新的文件数据（从fileList中重新获取，避免使用旧的对象引用）
                const latestFiles = files.map((file) => {
                    // 从最新的fileList中查找对应的文件，确保使用最新数据
                    const latestFile = this.fileList.find((f) => f.id === file.id || f.fileName === file.fileName);
                    return latestFile || file; // 如果找不到，使用原文件（兼容处理）
                });

                // 1. 必填字段校验
                const validationResult = this.validateFilesForImport(
                    latestFiles,
                    isSingleImport
                );
                if (!validationResult.isValid) {
                    ElMessage.warning(validationResult.message);
                    return;
                }

                // 2. 显示进度提示
                if (isSingleImport) {
                    ElMessage.info(`正在导入文件: ${latestFiles[0].fileName}...`);
                } else {
                    ElMessage.info(
                        `开始批量导入 ${latestFiles.length} 个文件到IoTDB...`
                    );
                }

                // 3. 文件存在性检查
                const fileCheckResult = await this.checkFilesExist(latestFiles);
                if (!fileCheckResult.allExist) {
                    ElMessage.error(fileCheckResult.message);
                    return;
                }

                // 4. 准备导入数据（使用最新的文件数据）
                const filesData = latestFiles.map((file) => {
                    const importData = this.prepareFileImportData(file);
                    return importData;
                });

                // 5. 执行导入 - 统一使用批量导入接口
                const endpoint = "/into-iotdb/file-record/batch-import-files";

                // 统一发送数组格式，单个导入时数组只有一个元素
                const response = await axios.post(endpoint, filesData, {
                    headers: { "Content-Type": "application/json" },
                });

                // 6. 处理导入结果
                if (isSingleImport) {
                    if (response.data.success) {
                        this.handleImportSuccess(files[0], response.data);
                    } else {
                        this.handleImportError(files[0], response.data.message);
                    }
                } else {
                    this.handleImportResponse(response, files);
                }
            } catch (error) {
                console.error(
                    `${isSingleImport ? "单个" : "批量"}导入失败:`,
                    error
                );
                const errorMessage =
                    error.response?.data?.message ||
                    error.message ||
                    "导入失败";

                if (isSingleImport) {
                    this.handleImportError(files[0], errorMessage);
                } else {
                    ElMessage.error(`批量导入失败: ${errorMessage}`);
                }
            }
        },

        // 验证文件列表的必填字段
        validateFilesForImport(files, isSingleImport) {
            const validationResults = files.map((file) => {
                const missingFields =
                    this.validateRequiredFieldsForImport(file);
                return {
                    file: file,
                    missingFields: missingFields,
                    isValid: missingFields.length === 0,
                };
            });

            const invalidFiles = validationResults.filter(
                (result) => !result.isValid
            );

            if (invalidFiles.length === 0) {
                return { isValid: true };
            }

            // 生成错误消息
            if (isSingleImport) {
                const fieldList = invalidFiles[0].missingFields.join("、");
                return {
                    isValid: false,
                    message: `请先填写以下必填字段后再导入：${fieldList}`,
                };
            } else {
                const invalidFileNames = invalidFiles
                    .map((result) => result.file.fileName)
                    .join(", ");
                const allMissingFields = [
                    ...new Set(
                        invalidFiles.flatMap((result) => result.missingFields)
                    ),
                ];
                const fieldList = allMissingFields.join("、");

                return {
                    isValid: false,
                    message: `以下文件缺少必填字段，请先填写后再导入：${invalidFileNames}\n缺少字段：${fieldList}`,
                };
            }
        },

        // 检查文件是否存在
        async checkFilesExist(files) {
            if (files.length === 1) {
                // 单个文件检查
                try {
                    const checkResponse = await axios.get(
                        "/into-iotdb/file-record/check-file-exists",
                        { params: { fileName: files[0].fileName } }
                    );

                    if (!checkResponse.data.success) {
                        return {
                            allExist: false,
                            message:
                                "检查文件存在性失败: " +
                                checkResponse.data.message,
                        };
                    }

                    if (!checkResponse.data.exists) {
                        return {
                            allExist: false,
                            message:
                                "文件夹下未找到目标文件: " + files[0].fileName,
                        };
                    }

                    return { allExist: true };
                } catch (error) {
                    return {
                        allExist: false,
                        message:
                            "检查文件存在性失败: " +
                            (error.response?.data?.message || error.message),
                    };
                }
            } else {
                // 批量文件检查
                const fileCheckPromises = files.map(async (file) => {
                    try {
                        const checkResponse = await axios.get(
                            "/into-iotdb/file-record/check-file-exists",
                            { params: { fileName: file.fileName } }
                        );
                        return {
                            file: file,
                            exists:
                                checkResponse.data.success &&
                                checkResponse.data.exists,
                            error: checkResponse.data.success
                                ? null
                                : checkResponse.data.message,
                        };
                    } catch (error) {
                        return {
                            file: file,
                            exists: false,
                            error:
                                error.response?.data?.message ||
                                error.message ||
                                "检查文件存在性失败",
                        };
                    }
                });

                const fileCheckResults = await Promise.all(fileCheckPromises);
                const missingFiles = fileCheckResults.filter(
                    (result) => !result.exists
                );

                if (missingFiles.length > 0) {
                    const missingFileNames = missingFiles
                        .map((result) => result.file.fileName)
                        .join(", ");
                    return {
                        allExist: false,
                        message: `以下文件在文件夹中未找到: ${missingFileNames}`,
                    };
                }

                return { allExist: true };
            }
        },

        // 验证导入必填字段
        validateRequiredFieldsForImport(file) {
            const requiredFields = [
                { field: "projectNo", name: "项目编号" },
                { field: "deviceNo", name: "台架编号" },
                { field: "company", name: "单位" },
                { field: "dataTypeFirst", name: "数据第一分类" },
                { field: "dataTypeSecond", name: "数据第二分类" },
                { field: "productPhase", name: "产品阶段" },
                { field: "dataSource", name: "数据来源" },
                { field: "startTime", name: "运行起始时间" },
                { field: "engineNo", name: "发动机编号" },
            ];

            const missingFields = [];
            requiredFields.forEach(({ field, name }) => {
                const value = file[field];
                // 对于字符串类型字段，检查是否为null或空字符串
                // 对于数字类型字段（dataTypeFirst, dataTypeSecond, productPhase），只检查是否为null或undefined
                if (
                    field === "dataTypeFirst" ||
                    field === "dataTypeSecond" ||
                    field === "productPhase"
                ) {
                    // 数字类型：只检查是否为null或undefined，0是有效值
                    if (value === null || value === undefined) {
                        missingFields.push(name);
                    }
                } else {
                    // 字符串类型：检查是否为null、undefined或空字符串
                    if (
                        !value ||
                        value === "" ||
                        (typeof value === "string" && value.trim() === "")
                    ) {
                        missingFields.push(name);
                    }
                }
            });

            return missingFields;
        },

        // 准备文件导入数据的公共方法
        prepareFileImportData(file) {
            return {
                id: file.id, // 添加ID字段，这是批量更新必需的
                fileName: file.fileName,
                // 添加文件基本信息
                projectNo: file.projectNo || "",
                place: file.place || "",
                company: file.company || "",
                productPhase: file.productPhase || 0,
                productPhaseDesc: file.productPhaseDesc || "",
                dataTypeFirst: file.dataTypeFirst || 0,
                dataTypeFirstDesc: file.dataTypeFirstDesc || "",
                dataTypeSecond: file.dataTypeSecond || 0,
                dataTypeSecondDesc: file.dataTypeSecondDesc || "",
                dataSource: file.dataSource || "",
                // startTime处理：如果是空字符串，转换为null；否则保持原值
                startTime: (file.startTime && file.startTime.trim && file.startTime.trim() !== "") 
                    ? file.startTime 
                    : (file.startTime || null),
                engineId: file.engineId || "",
                engineNo: file.engineNo || "",
                channelNo: file.channelNo || "",
                deviceNo: file.deviceNo || "",
                enginePlace: file.enginePlace || "",
                ecuId: file.ecuId || "",
                ecuNo: file.ecuNo || "",
                ecuSysId: file.ecuSysId || "",
                ecuSysNo: file.ecuSysNo || "",
                subject: file.subject || "",
                remark: file.remark || "",
                checkCode: file.checkCode || "",
                syncDataSource: file.syncDataSource || 0,
                syncStatus: file.syncStatus || 0,
                uploadStatus: file.uploadStatus || 0,
                importStatus: file.importStatus || 0,
                retryTime: file.retryTime || 0,
                // 批量更新方法：只设置 updateTime，createTime 和 uploadTime 保留不更新（由后端处理）
                updateTime: getLocalDateTimeString(), // 更新修改时间为当前本地时间
            };
        },

        // 处理导入响应的公共方法
        handleImportResponse(response, selectedFiles) {
            if (response.data.success) {
                const { successCount, failCount, totalCount, importResults } =
                    response.data;

                if (failCount === 0) {
                    ElMessage.success(
                        `批量导入成功！共导入 ${successCount} 个文件到IoTDB`
                    );
                } else if (successCount === 0) {
                    ElMessage.error(
                        `批量导入失败！所有 ${failCount} 个文件导入失败`
                    );
                } else {
                    ElMessage.warning(
                        `批量导入完成！成功: ${successCount}, 失败: ${failCount}`
                    );
                }

                // 更新文件状态
                this.updateFileStatusAfterImport(selectedFiles, importResults);

                // 清空选中状态
                this.clearFileSelections();

                // 批量导入完成后刷新页面数据
                this.loadFileList();
            } else {
                ElMessage.error(`批量导入失败: ${response.data.message}`);
            }
        },

        // 更新文件导入状态的公共方法
        updateFileStatusAfterImport(selectedFiles, importResults) {
            selectedFiles.forEach((file) => {
                const fileIndex = this.fileList.findIndex(
                    (f) => f.id === file.id
                );
                if (fileIndex !== -1) {
                    // 查找对应的导入结果
                    const importResult = importResults.find(
                        (result) => result.fileName === file.fileName
                    );
                    if (importResult && importResult.success) {
                        this.fileList[fileIndex].uploadStatus = 1;
                        this.fileList[fileIndex].importStatus = 1;
                        this.fileList[fileIndex].status = "已导入";
                        this.fileList[fileIndex].importTime =
                            new Date().toLocaleString("zh-CN");
                    } else {
                        this.fileList[fileIndex].status = "导入失败";
                        this.fileList[fileIndex].hasError = true;
                        this.fileList[fileIndex].errorMessage = importResult
                            ? importResult.message
                            : "导入失败";
                    }
                }
            });
        },

        // 清空文件选中状态的公共方法
        clearFileSelections() {
            this.fileList.forEach((file) => {
                file.selected = false;
            });
            this.selectAll = false;
        },

        // 显示导入进度
        showImportProgress(file) {
            ElMessage.info(`正在导入文件: ${file.fileName}...`);
        },

        // 处理导入成功
        handleImportSuccess(file, responseData) {
            ElMessage.success(`文件 ${file.fileName} 导入IoTDB成功`);

            // 更新文件状态为已导入
            const fileIndex = this.fileList.findIndex((f) => f.id === file.id);
            if (fileIndex !== -1) {
                this.fileList[fileIndex].uploadStatus = 1;
                this.fileList[fileIndex].importStatus = 1;
                this.fileList[fileIndex].status = "已导入";
                this.fileList[fileIndex].importTime = new Date().toLocaleString(
                    "zh-CN"
                );
            }

            // 导入完成后刷新页面数据
            this.loadFileList();
        },

        // 处理导入失败
        handleImportError(file, errorMessage) {
            ElMessage.error(`文件 ${file.fileName} 导入失败: ${errorMessage}`);

            // 更新文件状态为导入失败
            const fileIndex = this.fileList.findIndex((f) => f.id === file.id);
            if (fileIndex !== -1) {
                this.fileList[fileIndex].status = "导入失败";
                this.fileList[fileIndex].hasError = true;
                this.fileList[fileIndex].errorMessage = errorMessage;
            }

            console.error("文件导入失败:", errorMessage);
        },

        // 显示标签信息弹窗
        showTagInfo(file) {
            // 根据当前标签页和导入状态决定弹窗标题和编辑模式
            if (
                this.currentTab === "imported" ||
                this.currentTab === "error" ||
                file.importStatus === 1
            ) {
                // 已导入标签页、异常文件标签页或已导入的文件只能查看，不能编辑
                this.modalTitle = "标签信息详情";
                this.isEditMode = false;
            } else {
                // 未导入标签页且未导入的文件可以编辑
                this.modalTitle = "修改标签信息";
                this.isEditMode = true;
            }

            this.isBatchMode = false; //重置批量模式
            this.selectedFiles = []; //重置选中的文件

            // 使用文件对象的真实数据填充表单
            this.formData = {
                // 基础信息
                id: file.id || "",
                fileName: file.fileName || "", // 添加fileName字段，这是必需的
                projectNo: file.projectNo || "",
                place: file.place || "",
                company: file.company || "",
                productPhase: file.productPhase || "",
                dataTypeFirst: file.dataTypeFirst || "",
                dataTypeSecond: file.dataTypeSecond || "",
                dataSource: file.dataSource || "",
                startTime: file.startTime
                    ? this.formatDateTimeForInput(file.startTime)
                    : "",
                channelNo: file.channelNo || "",
                deviceNo: file.deviceNo || "",
                subject: file.subject || "",
                remark: file.remark || "",
                checkCode: file.checkCode || "",
                syncDataSource: file.syncDataSource || 0,
                syncStatus: file.syncStatus || 0,
                uploadStatus: file.uploadStatus || 0,
                retryTime: file.retryTime || 0,

                // 发动机信息
                engineId: file.engineId || "",
                engineNo: file.engineNo || "",
                enginePlace: file.enginePlace || "",

                // 控制器信息
                ecuId: file.ecuId || "",
                ecuNo: file.ecuNo || "",
                ecuSysId: file.ecuSysId || "",
                ecuSysNo: file.ecuSysNo || "",

                // 时间信息
                uploadTime: file.uploadTime
                    ? this.formatDateTimeForInput(file.uploadTime)
                    : "",
                // updateTime 不在表单中显示，但在更新时需要传递当前时间
                updateTime: getLocalDateTimeString(),
            };
            // 先设置编辑模式，再显示弹窗
            this.$nextTick(() => {
                this.showModal = true;
            });
        },

        // 格式化时间为HTML datetime-local输入框格式
        formatDateTimeForInput(dateTimeString) {
            if (!dateTimeString) return "";
            try {
                const date = new Date(dateTimeString);
                // 格式化为 yyyy-MM-dd HH:mm:ss 格式，与后端 @JsonFormat 注解匹配
                const year = date.getFullYear();
                const month = String(date.getMonth() + 1).padStart(2, "0");
                const day = String(date.getDate()).padStart(2, "0");
                const hours = String(date.getHours()).padStart(2, "0");
                const minutes = String(date.getMinutes()).padStart(2, "0");
                const seconds = String(date.getSeconds()).padStart(2, "0");
                return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
            } catch (error) {
                console.error("时间格式化失败:", error);
                return "";
            }
        },

        // 格式化时间为后端期望的格式
        formatDateTimeForBackend(dateTimeString) {
            if (!dateTimeString) return "";
            try {
                // 如果已经是 yyyy-MM-dd HH:mm:ss 格式，直接返回
                if (
                    typeof dateTimeString === "string" &&
                    /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(dateTimeString)
                ) {
                    return dateTimeString;
                }

                // 处理 YYYY-MM-DDTHH:mm 格式（缺少秒）
                if (
                    typeof dateTimeString === "string" &&
                    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(dateTimeString)
                ) {
                    // 补充秒为00
                    dateTimeString = dateTimeString + ":00";
                }

                // 将各种格式转换为 yyyy-MM-dd HH:mm:ss 格式
                const date = new Date(dateTimeString);
                if (isNaN(date.getTime())) {
                    console.error("无效的时间格式:", dateTimeString);
                    return "";
                }
                const year = date.getFullYear();
                const month = String(date.getMonth() + 1).padStart(2, "0");
                const day = String(date.getDate()).padStart(2, "0");
                const hours = String(date.getHours()).padStart(2, "0");
                const minutes = String(date.getMinutes()).padStart(2, "0");
                const seconds = String(date.getSeconds()).padStart(2, "0");
                return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
            } catch (error) {
                console.error(
                    "时间格式化失败:",
                    error,
                    "原始值:",
                    dateTimeString
                );
                return "";
            }
        },

        // 关闭弹窗
        closeModal() {
            this.showModal = false;
            this.isBatchMode = false; //重置批量模式
            this.selectedFiles = []; //重置选中的文件
        },

        // 保存标签信息
        async saveTagInfo() {
            try {
                if (this.isBatchMode) {
                    //批量修改模式
                    await this.batchSaveFileInfo(
                        this.formData,
                        this.selectedFiles
                    );
                } else {
                    //单个文件修改模式
                    await this.saveFileInfo(this.formData);
                }
                this.closeModal();
            } catch (error) {
                console.error("保存标签信息失败:", error);
            }
        },

        // 分页处理
        changePage(page) {
            this.currentPage = page;
            this.loadFileList(); // 重新加载数据
        },

        changePageSize(newPageSize) {
            this.pageSize = newPageSize;
            this.currentPage = 1;
            this.loadFileList(); // 重新加载数据
        },

        // 从后端加载文件列表数据
        async loadFileList() {
            try {
                const timestamp = Date.now();
                console.log(
                    "开始加载文件列表，页码:",
                    this.currentPage,
                    "页大小:",
                    this.pageSize,
                    "当前标签页:",
                    this.currentTab,
                    "时间戳:",
                    timestamp
                );

                // 根据当前标签页确定查询参数
                let uploadStatus = null;
                let importStatus = null;

                switch (this.currentTab) {
                    case "notImported":
                        // 未导入：已上传但未导入
                        uploadStatus = 1; // 1表示已上传
                        importStatus = 0; // 0表示未导入
                        break;
                    case "imported":
                        // 已导入：已上传且已导入
                        uploadStatus = 1; // 1表示已上传
                        importStatus = 1; // 1表示已导入
                        break;
                    case "error":
                        // 异常文件：上传失败或者上传成功但导入失败
                        uploadStatus = null; // 不限制上传状态，因为需要包含两种情况
                        importStatus = 2; // 2表示导入失败
                        break;
                }

                // 调用后端分页接口
                const response = await axios.get(
                    "/into-iotdb/file-record/query-paginated",
                    {
                        params: {
                            page: this.currentPage,
                            size: this.pageSize,
                            uploadStatus: uploadStatus,
                            importStatus: importStatus,
                        },
                    }
                );

                if (response.data.success) {
                    const { data, pagination } = response.data;

                    // 将后端返回的 FileRecordVO 对象转换为前端需要的格式
                    this.fileList = data.map((record) => ({
                        id: record.id,
                        fileName: record.fileName,
                        planeNo: record.planeNo,
                        engineId: record.engineId,
                        engineNo: record.engineNo,
                        enginePlace: record.enginePlace,
                        deviceNo: record.deviceNo,
                        uploadTime: record.uploadTime
                            ? new Date(record.uploadTime).toLocaleString(
                                  "zh-CN"
                              )
                            : new Date().toLocaleString("zh-CN"),
                        uploadStatus: record.uploadStatus,
                        importStatus: record.importStatus,
                        selected: false,
                        // 添加其他字段
                        projectNo: record.projectNo,
                        place: record.place,
                        company: record.company,
                        productPhase: record.productPhase,
                        dataTypeFirst: record.dataTypeFirst,
                        dataTypeSecond: record.dataTypeSecond,
                        dataSource: record.dataSource,
                        startTime: record.startTime,
                        channelNo: record.channelNo,
                        ecuId: record.ecuId,
                        ecuNo: record.ecuNo,
                        ecuSysId: record.ecuSysId,
                        ecuSysNo: record.ecuSysNo,
                        subject: record.subject,
                        remark: record.remark,
                        checkCode: record.checkCode,
                        syncDataSource: record.syncDataSource,
                        syncStatus: record.syncStatus,
                        createTime: record.createTime,
                        retryTime: record.retryTime,
                    }));

                    // 更新分页信息
                    this.totalFiles = pagination.totalCount;
                } else {
                    console.error("后端返回错误:", response.data.message);
                    ElMessage.error(
                        "加载文件列表失败: " + response.data.message
                    );
                }
            } catch (error) {
                console.error("加载文件列表失败:", error);
                ElMessage.error(
                    "加载文件列表失败: " +
                        (error.response?.data?.message ||
                            error.message ||
                            "网络错误")
                );
            }
        },

        async saveFileInfo(fileData) {
            try {
                // 确保时间字段格式正确
                const formattedData = { ...fileData };
                if (formattedData.startTime) {
                    formattedData.startTime = this.formatDateTimeForBackend(
                        formattedData.startTime
                    );
                }
                if (formattedData.uploadTime) {
                    formattedData.uploadTime = this.formatDateTimeForBackend(
                        formattedData.uploadTime
                    );
                }

                // 调用后端API进行单个文件更新
                const response = await axios.put(
                    `/into-iotdb/file-record/update`,
                    formattedData
                );

                if (response.data.success) {
                    ElMessage.success("文件信息保存成功");

                    // 刷新文件列表
                    await this.loadFileList();

                    return { success: true, message: "保存成功" };
                } else {
                    ElMessage.error("保存失败: " + response.data.message);
                    throw new Error(response.data.message);
                }
            } catch (error) {
                console.error("保存文件信息失败:", error);
                const errorMessage =
                    error.response?.data?.message ||
                    error.message ||
                    "保存失败";
                ElMessage.error("保存文件信息失败: " + errorMessage);
                throw error;
            }
        },

        async batchSaveFileInfo(fileData, selectedFiles) {
            try {
                // 构建要更新的文件记录列表
                const fileRecordVOs = selectedFiles.map((file) => {
                    // 处理时间字段格式化
                    let formattedStartTime = null;
                    if (fileData.startTime) {
                        formattedStartTime = this.formatDateTimeForBackend(
                            fileData.startTime
                        );
                    } else if (file.startTime) {
                        // 如果file.startTime已经是格式化的字符串，直接使用；否则格式化
                        formattedStartTime =
                            typeof file.startTime === "string" &&
                            file.startTime.includes(" ")
                                ? file.startTime
                                : this.formatDateTimeForBackend(file.startTime);
                    }

                    let formattedUploadTime = null;
                    if (fileData.uploadTime) {
                        formattedUploadTime = this.formatDateTimeForBackend(
                            fileData.uploadTime
                        );
                    } else if (file.uploadTime) {
                        formattedUploadTime =
                            typeof file.uploadTime === "string" &&
                            file.uploadTime.includes(" ")
                                ? file.uploadTime
                                : this.formatDateTimeForBackend(
                                      file.uploadTime
                                  );
                    }

                    // 合并文件原有数据和表单数据
                    // 对于字符串字段，如果表单值为空字符串，保留原值；如果有值，使用表单值
                    const updatedRecord = {
                        id: file.id, // 确保包含ID
                        fileName: file.fileName,
                        projectNo: fileData.projectNo || file.projectNo,
                        place: fileData.place || file.place,
                        company: fileData.company || file.company,
                        productPhase:
                            fileData.productPhase || file.productPhase,
                        dataTypeFirst:
                            fileData.dataTypeFirst || file.dataTypeFirst,
                        dataTypeSecond:
                            fileData.dataTypeSecond || file.dataTypeSecond,
                        dataSource: fileData.dataSource || file.dataSource,
                        startTime: formattedStartTime,
                        engineId: fileData.engineId || file.engineId,
                        engineNo: fileData.engineNo || file.engineNo,
                        channelNo: fileData.channelNo || file.channelNo,
                        // deviceNo: 如果表单有值（非空字符串），使用表单值；否则保留原值
                        deviceNo: (fileData.deviceNo && fileData.deviceNo.trim() !== "") 
                            ? fileData.deviceNo 
                            : (file.deviceNo || ""),
                        enginePlace: fileData.enginePlace || file.enginePlace,
                        ecuId: fileData.ecuId || file.ecuId,
                        ecuNo: fileData.ecuNo || file.ecuNo,
                        ecuSysId: fileData.ecuSysId || file.ecuSysId,
                        ecuSysNo: fileData.ecuSysNo || file.ecuSysNo,
                        subject: fileData.subject || file.subject,
                        remark: fileData.remark || file.remark,
                        checkCode: file.checkCode,
                        syncDataSource:
                            fileData.syncDataSource || file.syncDataSource,
                        uploadStatus: file.uploadStatus,
                        importStatus: file.importStatus,
                        syncStatus: file.syncStatus,
                        retryTime: file.retryTime,
                        uploadTime: formattedUploadTime || file.uploadTime,
                        updateTime: getLocalDateTimeString(), // 更新修改时间为当前本地时间
                    };
                    return updatedRecord;
                });

                // 调用后端API进行批量更新
                const response = await axios.post(
                    "/into-iotdb/file-record/batch-update",
                    fileRecordVOs
                );

                if (response.data.success) {
                    ElMessage.success(
                        `批量更新成功，共更新 ${response.data.updateCount} 条记录`
                    );

                    // 刷新文件列表
                    await this.loadFileList();

                    // 清空选中状态
                    this.fileList.forEach((file) => {
                        file.selected = false;
                    });
                    this.selectAll = false;
                } else {
                    ElMessage.error("批量更新失败: " + response.data.message);
                }
            } catch (error) {
                console.error("批量保存文件信息失败:", error);
                const errorMessage =
                    error.response?.data?.message ||
                    error.message ||
                    "批量更新失败";
                ElMessage.error("批量保存文件信息失败: " + errorMessage);
                throw error;
            }
        },

        async uploadFiles(files) {
            try {
                // 模拟上传进度
                for (let i = 0; i <= 100; i += 10) {
                    await new Promise((resolve) => setTimeout(resolve, 100));
                }

                // 模拟添加新文件到列表
                files.forEach((file, index) => {
                    const newFile = {
                        id: this.fileList.length + index + 1,
                        fileName: file.name,
                        planeNo: `PL${String(
                            this.fileList.length + index + 1
                        ).padStart(3, "0")}`,
                        engineNo: `ENG${String(
                            this.fileList.length + index + 1
                        ).padStart(3, "0")}`,
                        enginePlace: "左发",
                        deviceNo: `RIG${String(
                            this.fileList.length + index + 1
                        ).padStart(3, "0")}`,
                        uploadTime: new Date().toLocaleString("zh-CN"),
                        uploadStatus: 1,
                        importStatus: 0,
                        selected: false,
                        fileSize: `${(file.size / 1024 / 1024).toFixed(1)}MB`,
                        dataType: "新上传数据",
                        status: "已处理",
                    };
                    this.fileList.unshift(newFile);
                });

                this.totalFiles = this.fileList.length;

                return { success: true, uploadedCount: files.length };
            } catch (error) {
                console.error("文件上传失败:", error);
                ElMessage.error("文件上传失败");
                throw error;
            }
        },

        async deleteFile(fileId) {
            try {
                // 模拟API延迟
                await new Promise((resolve) => setTimeout(resolve, 500));

                const fileIndex = this.fileList.findIndex(
                    (file) => file.id === fileId
                );
                if (fileIndex !== -1) {
                    const fileName = this.fileList[fileIndex].fileName;
                    this.fileList.splice(fileIndex, 1);
                    this.totalFiles = this.fileList.length;
                    ElMessage.success(`文件 ${fileName} 删除成功`);
                } else {
                    ElMessage.error("文件不存在");
                }
            } catch (error) {
                console.error("删除文件失败:", error);
                ElMessage.error("删除文件失败");
                throw error;
            }
        },

        // 组件事件处理方法
        async handleFilesSelected(files) {
            try {
                await this.uploadFiles(files);
            } catch (error) {
                console.error("文件上传失败:", error);
            }
        },

        // 处理上传成功
        handleUploadSuccess(responseData) {
            // 延迟刷新文件列表，确保数据库事务已完成提交
            // 这样可以避免获取到旧的或部分数据，导致显示重复或不完整的数据
            setTimeout(() => {
                this.loadFileList();
            }, 300); // 延迟300ms，确保数据库事务完成
        },

        // 处理上传失败
        handleUploadError(error) {
            console.error("文件上传失败:", error);
            const errorMessage =
                error.response?.data?.message || error.message || "上传失败";
            ElMessage.error("文件上传失败：" + errorMessage);
        },
        // 处理标签页切换
        handleTabChange(tabName) {
            this.currentTab = tabName; // 更新当前标签页
            //重置分页到第一页
            this.currentPage = 1;
            // 重置全选状态
            this.selectAll = false;
            // 重新加载数据
            this.loadFileList();
        },
    },

    mounted() {
        // 应用初始化
        console.log("PLPM IoTDB 数据管理系统已启动");

        // 配置Axios默认设置
        axios.defaults.baseURL = window.location.origin;
        axios.defaults.timeout = 10000;

        // 加载文件列表数据
        this.loadFileList();

        // 添加请求拦截器
        axios.interceptors.request.use(
            (config) => {
                // 可以在这里添加认证token等
                return config;
            },
            (error) => {
                return Promise.reject(error);
            }
        );

        // 添加响应拦截器
        axios.interceptors.response.use(
            (response) => {
                return response;
            },
            (error) => {
                console.error("请求错误:", error);
                if (error.response) {
                    ElMessage.error(
                        `请求失败: ${error.response.status} ${error.response.statusText}`
                    );
                } else if (error.request) {
                    ElMessage.error("网络连接失败，请检查网络");
                } else {
                    ElMessage.error("请求配置错误");
                }
                return Promise.reject(error);
            }
        );
    },
});

// 注册组件
app.component("file-upload", FileUpload);
app.component("file-list", FileList);
app.component("tag-info-modal", TagInfoModal);

// 使用Element Plus
app.use(ElementPlus);

// 挂载应用
app.mount("#app");

// ==================== 时间戳缓存破坏功能 ====================

// 工具函数：生成时间戳参数避免缓存
function addTimestampToParams(params = {}) {
    return {
        ...params,
        _t: Date.now(), // 添加时间戳参数
    };
}

// 工具函数：为URL添加时间戳参数
function addTimestampToUrl(url) {
    const separator = url.includes("?") ? "&" : "?";
    return `${url}${separator}_t=${Date.now()}`;
}

// 智能检测环境
function isDevelopmentEnvironment() {
    const hostname = window.location.hostname;
    const port = window.location.port;

    // 开发环境判断条件
    const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1";
    const isDevPort = port === "8080" || port === "3000" || port === "8081";
    const hasDevIndicator =
        hostname.includes("dev") || hostname.includes("test");

    return isLocalhost || isDevPort || hasDevIndicator;
}

// 缓存破坏配置 - 智能控制
const CACHE_BUSTING_CONFIG = {
    enabled: isDevelopmentEnvironment(), // 智能控制：开发环境启用，生产环境禁用
    excludeUrls: [
        // 排除的URL列表（不需要缓存破坏的接口）
        "/into-iotdb/files/upload/", // 文件上传相关接口
        "/into-iotdb/file-record/insert", // 插入接口
        "/into-iotdb/file-record/update", // 更新接口
        "/into-iotdb/file-record/batch-update", // 批量更新接口
    ],
};

// 手动控制缓存破坏的便捷方法
window.toggleCacheBusting = function (enable) {
    CACHE_BUSTING_CONFIG.enabled = enable;
    console.log(`缓存破坏功能已${enable ? "启用" : "禁用"}`);
    return CACHE_BUSTING_CONFIG.enabled;
};

// 获取当前缓存破坏状态
window.getCacheBustingStatus = function () {
    return CACHE_BUSTING_CONFIG.enabled;
};

// 获取环境信息
window.getEnvironmentInfo = function () {
    const hostname = window.location.hostname;
    const port = window.location.port;
    const isDev = isDevelopmentEnvironment();

    console.log("环境信息:", {
        hostname: hostname,
        port: port,
        isDevelopment: isDev,
        cacheBustingEnabled: CACHE_BUSTING_CONFIG.enabled,
    });

    return {
        hostname: hostname,
        port: port,
        isDevelopment: isDev,
        cacheBustingEnabled: CACHE_BUSTING_CONFIG.enabled,
    };
};

// 启动时显示环境信息
console.log("=== 缓存破坏智能控制 ===");
console.log("当前环境:", window.location.hostname + ":" + window.location.port);
console.log("环境类型:", isDevelopmentEnvironment() ? "开发环境" : "生产环境");
console.log("缓存破坏:", CACHE_BUSTING_CONFIG.enabled ? "已启用" : "已禁用");

// 配置axios拦截器，自动为GET请求添加时间戳参数避免缓存
axios.interceptors.request.use(
    function (config) {
        // 检查是否启用缓存破坏
        if (!CACHE_BUSTING_CONFIG.enabled) {
            return config;
        }

        // 检查是否在排除列表中
        const shouldExclude = CACHE_BUSTING_CONFIG.excludeUrls.some(
            (url) => config.url && config.url.includes(url)
        );

        if (shouldExclude) {
            return config;
        }

        // 只为GET请求添加时间戳参数
        if (config.method === "get") {
            // 如果已经有_t参数，则更新它
            if (config.params) {
                config.params._t = Date.now();
            } else {
                config.params = { _t: Date.now() };
            }
        }
        return config;
    },
    function (error) {
        return Promise.reject(error);
    }
);

/**
 * 获取本地时间字符串，格式：yyyy-MM-dd HH:mm:ss
 * @returns {string} 格式化的本地时间字符串
 */
function getLocalDateTimeString() {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, "0");
    const day = String(now.getDate()).padStart(2, "0");
    const hours = String(now.getHours()).padStart(2, "0");
    const minutes = String(now.getMinutes()).padStart(2, "0");
    const seconds = String(now.getSeconds()).padStart(2, "0");
    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}
